# -*- coding: utf-8 -*-
from gi.repository import GObject
CLIENT_PROP_DBUS_NAME = r"""dbus-name"""
CLIENT_PROP_DBUS_OBJECT = r"""dbus-object"""
CLIENT_PROP_GROUP_EVENTS = r"""group-events"""
CLIENT_PROP_STATUS = r"""status"""
CLIENT_PROP_TEXT_DIRECTION = r"""text-direction"""
CLIENT_SIGNAL_EVENT_RESULT = r"""event-result"""
CLIENT_SIGNAL_ICON_THEME_DIRS_CHANGED = r"""icon-theme-dirs-changed"""
CLIENT_SIGNAL_ITEM_ACTIVATE = r"""item-activate"""
CLIENT_SIGNAL_LAYOUT_UPDATED = r"""layout-updated"""
CLIENT_SIGNAL_NEW_MENUITEM = r"""new-menuitem"""
CLIENT_SIGNAL_ROOT_CHANGED = r"""root-changed"""
CLIENT_TYPES_DEFAULT = r"""standard"""
CLIENT_TYPES_IMAGE = r"""standard"""
CLIENT_TYPES_SEPARATOR = r"""separator"""
MENUITEM_CHILD_DISPLAY_SUBMENU = r"""submenu"""
MENUITEM_DISPOSITION_ALERT = r"""alert"""
MENUITEM_DISPOSITION_INFORMATIVE = r"""informative"""
MENUITEM_DISPOSITION_NORMAL = r"""normal"""
MENUITEM_DISPOSITION_WARNING = r"""warning"""
MENUITEM_EVENT_ACTIVATED = r"""clicked"""
MENUITEM_EVENT_CLOSED = r"""closed"""
MENUITEM_EVENT_OPENED = r"""opened"""
MENUITEM_ICON_NAME_BLANK = r"""blank-icon"""
MENUITEM_PROP_ACCESSIBLE_DESC = r"""accessible-desc"""
MENUITEM_PROP_CHILD_DISPLAY = r"""children-display"""
MENUITEM_PROP_DISPOSITION = r"""disposition"""
MENUITEM_PROP_ENABLED = r"""enabled"""
MENUITEM_PROP_ICON_DATA = r"""icon-data"""
MENUITEM_PROP_ICON_NAME = r"""icon-name"""
MENUITEM_PROP_LABEL = r"""label"""
MENUITEM_PROP_SHORTCUT = r"""shortcut"""
MENUITEM_PROP_TOGGLE_STATE = r"""toggle-state"""
MENUITEM_PROP_TOGGLE_TYPE = r"""toggle-type"""
MENUITEM_PROP_TYPE = r"""type"""
MENUITEM_PROP_VISIBLE = r"""visible"""
MENUITEM_SHORTCUT_ALT = r"""Alt"""
MENUITEM_SHORTCUT_CONTROL = r"""Control"""
MENUITEM_SHORTCUT_SHIFT = r"""Shift"""
MENUITEM_SHORTCUT_SUPER = r"""Super"""
MENUITEM_SIGNAL_ABOUT_TO_SHOW = r"""about-to-show"""
MENUITEM_SIGNAL_CHILD_ADDED = r"""child-added"""
MENUITEM_SIGNAL_CHILD_MOVED = r"""child-moved"""
MENUITEM_SIGNAL_CHILD_REMOVED = r"""child-removed"""
MENUITEM_SIGNAL_EVENT = r"""event"""
MENUITEM_SIGNAL_ITEM_ACTIVATED = r"""item-activated"""
MENUITEM_SIGNAL_PROPERTY_CHANGED = r"""property-changed"""
MENUITEM_SIGNAL_REALIZED = r"""realized"""
MENUITEM_SIGNAL_SHOW_TO_USER = r"""show-to-user"""
MENUITEM_TOGGLE_CHECK = r"""checkmark"""
MENUITEM_TOGGLE_RADIO = r"""radio"""
MENUITEM_TOGGLE_STATE_CHECKED = r"""1"""
MENUITEM_TOGGLE_STATE_UNCHECKED = r"""0"""
MENUITEM_TOGGLE_STATE_UNKNOWN = r"""-1"""
SERVER_PROP_DBUS_OBJECT = r"""dbus-object"""
SERVER_PROP_ROOT_NODE = r"""root-node"""
SERVER_PROP_STATUS = r"""status"""
SERVER_PROP_TEXT_DIRECTION = r"""text-direction"""
SERVER_PROP_VERSION = r"""version"""
SERVER_SIGNAL_ID_PROP_UPDATE = r"""item-property-updated"""
SERVER_SIGNAL_ID_UPDATE = r"""item-updated"""
SERVER_SIGNAL_ITEM_ACTIVATION = r"""item-activation-requested"""
SERVER_SIGNAL_LAYOUT_UPDATED = r"""layout-updated"""


class Status:
    """Tracks how the menus should be presented to the user."""
    NORMAL = 0
    NOTICE = 1


class TextDirection:
    """The direction of text that the strings that this server
	will be sending strings as."""
    NONE = 0
    LTR = 1
    RTL = 2


class Client(GObject.Object):
    """The client for a #DbusmenuServer creating a shared
	object set of #DbusmenuMenuitem objects."""
    
    def __init__(self, name=None, object=None):
        """        This function creates a new client that connects to a specific
        server on DBus.  That server is at a specific location sharing
        a known object.  The interface is assumed by the code to be
        the DBus menu interface.  The newly created client will start
        sending out events as it syncs up with the server.
        @param name: The DBus name for the server to connect to
        @param object: The object on the server to monitor
        @type name: str
        @type object: str
        @returns: Newly created Client
        @rtype: Client
        """
        return object
    @staticmethod
    def new(name=None, object=None):
        """        This function creates a new client that connects to a specific
        server on DBus.  That server is at a specific location sharing
        a known object.  The interface is assumed by the code to be
        the DBus menu interface.  The newly created client will start
        sending out events as it syncs up with the server.
        @param name: The DBus name for the server to connect to
        @param object: The object on the server to monitor
        @type name: str
        @type object: str
        @returns: Newly created Client
        @rtype: Client
        """
        return object
    
    def add_type_handler(self, type=None, newfunc=None):
        """        This function connects into the type handling of the #DbusmenuClient.
        Every new menuitem that comes in immediately gets asked for its
        properties.  When we get those properties we check the 'type'
        property and look to see if it matches a handler that is known
        by the client.  If so, the @newfunc function is executed on that
        #DbusmenuMenuitem.  If not, then the DbusmenuClient::new-menuitem
        signal is sent.
        
        In the future the known types will be sent to the server so that it
        can make choices about the menu item types availble.
        @param type: A text string that will be matched with the 'type'     property on incoming menu items
        @param newfunc: The function that will be executed with those new     items when they come in.
        @type type: str
        @type newfunc: ClientTypeHandler
        @returns: If registering the new type was successful.
        @rtype: bool
        """
        return object
    
    def add_type_handler_full(self, type=None, newfunc=None, user_data=None, destroy_func=None):
        """        This function connects into the type handling of the #DbusmenuClient.
        Every new menuitem that comes in immediately gets asked for its
        properties.  When we get those properties we check the 'type'
        property and look to see if it matches a handler that is known
        by the client.  If so, the @newfunc function is executed on that
        #DbusmenuMenuitem.  If not, then the DbusmenuClient::new-menuitem
        signal is sent.
        
        In the future the known types will be sent to the server so that it
        can make choices about the menu item types availble.
        @param type: A text string that will be matched with the 'type'     property on incoming menu items
        @param newfunc: The function that will be executed with those new     items when they come in.
        @param user_data: Data passed to @newfunc when it is called
        @param destroy_func: A function that is called when the type handler is 	removed (usually on client destruction) which will free 	the resources in @user_data.
        @type type: str
        @type newfunc: ClientTypeHandler
        @type user_data: gpointer
        @type destroy_func: GLib.DestroyNotify
        @returns: If registering the new type was successful.
        @rtype: bool
        """
        return object
    
    def get_icon_paths(self):
        """        Gets the stored and exported icon paths from the client.
        @rtype: None
        """
        return object
    
    def get_root(self):
        """        Grabs the root node for the specified client @client.  This
        function may block.  It will block if there is currently a
        call to update the layout, it will block on that layout
        updated and then return the newly updated layout.  Chances
        are that this update is in the queue for the mainloop as
        it would have been requested some time ago, but in theory
        it could block longer.
        @returns: A #DbusmenuMenuitem representing the root of 	menu on the server.  If there is no server or there is 	an error receiving its layout it'll return #NULL.
        @rtype: Menuitem
        """
        return object
    
    def get_status(self):
        """        Gets the recommended current status that the server
        	is exporting for the menus.  In situtations where the
        	value is #DBUSMENU_STATUS_NOTICE it is recommended that
        	the client show the menus to the user an a more noticible
        	way.
        
        	Return value: Status being exported.
        @returns: 
        @rtype: Status
        """
        return object
    
    def get_text_direction(self):
        """        Gets the text direction that the server is exporting.  If
        	the server is not exporting a direction then the value
        	#DBUSMENU_TEXT_DIRECTION_NONE will be returned.
        
        	Return value: Text direction being exported.
        @returns: 
        @rtype: TextDirection
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def priv(self):
        return object


class ClientClass():
    """A simple class that takes all of the information from a
	#DbusmenuServer over DBus and makes the same set of
	#DbusmenuMenuitem objects appear on the other side."""

    @property
    def parent_class(self):
        return object

    @property
    def layout_updated(self):
        return object

    @property
    def root_changed(self):
        return object

    @property
    def new_menuitem(self):
        return object

    @property
    def item_activate(self):
        return object

    @property
    def event_result(self):
        return object

    @property
    def icon_theme_dirs(self):
        return object

    @property
    def reserved1(self):
        return object

    @property
    def reserved2(self):
        return object

    @property
    def reserved3(self):
        return object

    @property
    def reserved4(self):
        return object

    @property
    def reserved5(self):
        return object


class ClientPrivate():
    """"""


class Menuitem(GObject.Object):
    """This is the #GObject based object that represents a menu
item.  It gets created the same on both the client and
the server side and libdbusmenu-glib does the work of making
this object model appear on both sides of DBus.  Simple
really, though through updates and people coming on and off
the bus it can lead to lots of fun complex scenarios."""
    
    def __init__(self):
        """        Create a new #DbusmenuMenuitem with all default values.
        @returns: Newly created Menuitem
        @rtype: Menuitem
        """
        return object
    @staticmethod
    def new():
        """        Create a new #DbusmenuMenuitem with all default values.
        @returns: Newly created Menuitem
        @rtype: Menuitem
        """
        return object
    @staticmethod
    def new_with_id(id=None):
        """        This creates a blank #DbusmenuMenuitem with a specific ID.
        @param id: ID to use for this menuitem
        @type id: int
        @returns: Newly created Menuitem
        @rtype: Menuitem
        """
        return object
    
    def child_added(self, position=None):
        """        
        @type position: int
        @returns: 
        @rtype: None
        """
        return object
    
    def child_moved(self, newpos=None, oldpos=None):
        """        
        @type newpos: int
        @type oldpos: int
        @returns: 
        @rtype: None
        """
        return object
    
    def child_removed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def handle_event(self, name=None, variant=None, timestamp=None):
        """        This function is called to create an event.  It is likely
        to be overrided by subclasses.  The default menu item
        will respond to the activate signal and do:
        
        Emits the #DbusmenuMenuitem::item-activate signal on this
        menu item.  Called by server objects when they get the
        appropriate DBus signals from the client.
        
        If you subclass this function you should really think
        about calling the parent function unless you have a good
        reason not to.
        @param name: The name of the signal
        @param variant: A value that could be set for the event
        @param timestamp: The timestamp of when the event happened
        @type name: str
        @type variant: GLib.Variant
        @type timestamp: int
        @returns: 
        @rtype: None
        """
        return object
    
    def send_about_to_show(self, cb=None, cb_data=None):
        """        This function is used to send the even that the submenu
        of this item is about to be shown.  Callers to this event
        should delay showing the menu until their callback is
        called if possible.
        @param cb: Callback to call when the call has returned.
        @param cb_data: Data to pass to the callback.
        @type cb: object
        @type cb_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def show_to_user(self, timestamp=None, cb_data=None):
        """        
        @type timestamp: int
        @type cb_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def child_add_position(self, child=None, position=None):
        """        Puts @child in the list of children for @mi at the location
        specified in @position.  If there is not enough entires available
        then @child will be placed at the end of the list.
        @param child: The #DbusmenuMenuitem to make a child of @mi.
        @param position: Where in @mi object's list of chidren @child should be placed.
        @type child: Menuitem
        @type position: int
        @returns: Whether @child was added successfully.
        @rtype: bool
        """
        return object
    
    def child_append(self, child=None):
        """        This function adds @child to the list of children on @mi at
        the end of that list.
        @param child: The #DbusmenMenuitem that will be a child
        @type child: Menuitem
        @returns: Whether the child has been added successfully.
        @rtype: bool
        """
        return object
    
    def child_delete(self, child=None):
        """        This function removes @child from the children list of @mi.  It does
        not call #g_object_unref on @child.
        @param child: The child #DbusmenuMenuitem that you want to no longer     be a child of @mi.
        @type child: Menuitem
        @returns: If we were able to delete @child.
        @rtype: bool
        """
        return object
    
    def child_find(self, id=None):
        """        Search the children of @mi to find one with the ID of @id.
        If it doesn't exist then we return #NULL.
        @param id: The ID of the child that we're looking for.
        @type id: int
        @returns: The menu item with the ID @id or #NULL if it
    can't be found.
        @rtype: Menuitem
        """
        return object
    
    def child_prepend(self, child=None):
        """        This function adds @child to the list of children on @mi at
        the beginning of that list.
        @param child: The #DbusmenMenuitem that will be a child
        @type child: Menuitem
        @returns: Whether the child has been added successfully.
        @rtype: bool
        """
        return object
    
    def child_reorder(self, child=None, position=None):
        """        This function moves a child on the list of children.  It is
        for a child that is already in the list, but simply needs a
        new location.
        @param child: The #DbusmenuMenuitem that is a child needing to be moved
        @param position: The position in the list to place it in
        @type child: Menuitem
        @type position: int
        @returns: Whether the move was successful.
        @rtype: bool
        """
        return object
    
    def find_id(self, id=None):
        """        This function searchs the whole tree of children that
        are attached to @mi.  This could be quite a few nodes, all
        the way down the tree.  It is a depth first search.
        @param id: ID of the #DbusmenuMenuitem to search for
        @type id: int
        @returns: The #DbusmenuMenuitem with the ID of @id 	or #NULL if there isn't such a menu item in the tree 	represented by @mi.
        @rtype: Menuitem
        """
        return object
    
    def foreach(self, func=None, data=None):
        """        This calls the function @func on this menu item and all
        of the children of this item.  And their children.  And
        their children.  And... you get the point.  It will get
        called on the whole tree.
        @param func: Function to call on every node in the tree
        @param data: User data to pass to the function
        @type func: gpointer
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def get_children(self):
        """        Returns simply the list of children that this menu item
        has.  The list is valid until another child related function
        is called, where it might be changed.
        @returns: A #GList of pointers to #DbusmenuMenuitem objects.
        @rtype: GLib.List
        """
        return object
    
    def get_id(self):
        """        Gets the unique ID for @mi.
        @returns: The ID of the @mi.
        @rtype: int
        """
        return object
    
    def get_parent(self):
        """        This function looks up the parent of @mi
        @returns: The parent of this menu item
        @rtype: Menuitem
        """
        return object
    
    def get_position(self, parent=None):
        """        This function returns the position of the menu item @mi
        in the children of @parent.  It will return zero if the
        menu item can't be found.
        @param parent: The #DbusmenuMenuitem who's children contain @mi
        @type parent: Menuitem
        @returns: The position of @mi in the children of @parent.
        @rtype: int
        """
        return object
    
    def get_position_realized(self, parent=None):
        """        This function is very similar to #dbusmenu_menuitem_get_position
        except that it only counts in the children that have been realized.
        @param parent: The #DbusmenuMenuitem who's children contain @mi
        @type parent: Menuitem
        @returns: The position of @mi in the realized children of @parent.
        @rtype: int
        """
        return object
    
    def get_root(self):
        """        This function returns the internal value of whether this is a
        root node or not.
        @returns: #TRUE if this is a root node
        @rtype: bool
        """
        return object
    
    def handle_event(self, name=None, variant=None, timestamp=None):
        """        This function is called to create an event.  It is likely
        to be overrided by subclasses.  The default menu item
        will respond to the activate signal and do:
        
        Emits the #DbusmenuMenuitem::item-activate signal on this
        menu item.  Called by server objects when they get the
        appropriate DBus signals from the client.
        
        If you subclass this function you should really think
        about calling the parent function unless you have a good
        reason not to.
        @param name: The name of the signal
        @param variant: A value that could be set for the event
        @param timestamp: The timestamp of when the event happened
        @type name: str
        @type variant: GLib.Variant
        @type timestamp: int
        @returns: 
        @rtype: None
        """
        return object
    
    def properties_copy(self):
        """        This function takes the properties of a #DbusmenuMenuitem
        and puts them into a #GHashTable that is referenced by the
        key of a string and has the value of a string.  The hash
        table may not have any entries if there aren't any or there
        is an error in processing.  It is the caller's responsibility
        to destroy the created #GHashTable.
        @returns: A brand new #GHashTable that contains all of
    theroperties that are on this #DbusmenuMenuitem @mi.
        @rtype: GLib.HashTable
        """
        return object
    
    def properties_list(self):
        """        This functiong gets a list of the names of all the properties
        that are set on this menu item.  This data on the list is owned
        by the menuitem but the list is not and should be freed using
        g_list_free() when the calling function is done with it.
        @returns: A list of strings or NULL if there are none.
        @rtype: GLib.List
        """
        return object
    
    def property_exist(self, property=None):
        """        Checkes to see if a particular property exists on @mi and
        returns #TRUE if so.
        @param property: The property to look for.
        @type property: str
        @returns: A boolean checking to see if the property is available
        @rtype: bool
        """
        return object
    
    def property_get(self, property=None):
        """        Look up a property on @mi and return the value of it if
        it exits.  #NULL will be returned if the property doesn't
        exist.
        @param property: The property to grab.
        @type property: str
        @returns: A string with the value of the property 	that shouldn't be free'd.  Or #NULL if the property 	is not set or is not a string.
        @rtype: str
        """
        return object
    
    def property_get_bool(self, property=None):
        """        Look up a property on @mi and return the value of it if
        it exits.  Returns #FALSE if the property doesn't exist.
        @param property: The property to grab.
        @type property: str
        @returns: The value of the property or #FALSE.
        @rtype: bool
        """
        return object
    
    def property_get_byte_array(self, property=None, nelements=None):
        """        Look up a property on @mi and return the value of it if
        it exits.  #NULL will be returned if the property doesn't
        exist.
        @param property: The property to grab.
        @param nelements: A pointer to the location to store the number of items (out)
        @type property: str
        @type nelements: gsize
        @rtype: None
        """
        return object
    
    def property_get_int(self, property=None):
        """        Look up a property on @mi and return the value of it if
        it exits.  Returns zero if the property doesn't exist.
        @param property: The property to grab.
        @type property: str
        @returns: The value of the property or zero.
        @rtype: int
        """
        return object
    
    def property_get_variant(self, property=None):
        """        Look up a property on @mi and return the value of it if
        it exits.  #NULL will be returned if the property doesn't
        exist.
        @param property: The property to grab.
        @type property: str
        @returns: A GVariant for the property.
        @rtype: GLib.Variant
        """
        return object
    
    def property_remove(self, property=None):
        """        Removes a property from the menuitem.
        @param property: The property to look for.
        @type property: str
        @returns: 
        @rtype: None
        """
        return object
    
    def property_set(self, property=None, value=None):
        """        Takes the pair of @property and @value and places them as a
        property on @mi.  If a property already exists by that name,
        then the value is set to the new value.  If not, the property
        is added.  If the value is changed or the property was previously
        unset then the signal #DbusmenuMenuitem::prop-changed will be
        emitted by this function.
        @param property: Name of the property to set.
        @param value: The value of the property.
        @type property: str
        @type value: str
        @returns: A boolean representing if the property value was set.
        @rtype: bool
        """
        return object
    
    def property_set_bool(self, property=None, value=None):
        """        Takes a boolean @value and sets it on @property as a
        property on @mi.  If a property already exists by that name,
        then the value is set to the new value.  If not, the property
        is added.  If the value is changed or the property was previously
        unset then the signal #DbusmenuMenuitem::prop-changed will be
        emitted by this function.
        @param property: Name of the property to set.
        @param value: The value of the property.
        @type property: str
        @type value: bool
        @returns: A boolean representing if the property value was set.
        @rtype: bool
        """
        return object
    
    def property_set_byte_array(self, property=None, value=None, nelements=None):
        """        Takes a byte array @value and sets it on @property as a
        property on @mi.  If a property already exists by that name,
        then the value is set to the new value.  If not, the property
        is added.  If the value is changed or the property was previously
        unset then the signal #DbusmenuMenuitem::prop-changed will be
        emitted by this function.
        @param property: Name of the property to set.
        @param value: The byte array.
        @param nelements: The number of elements in the byte array.
        @type property: str
        @type value: guint8
        @type nelements: gsize
        @returns: A boolean representing if the property value was set.
        @rtype: bool
        """
        return object
    
    def property_set_int(self, property=None, value=None):
        """        Takes a boolean @value and sets it on @property as a
        property on @mi.  If a property already exists by that name,
        then the value is set to the new value.  If not, the property
        is added.  If the value is changed or the property was previously
        unset then the signal #DbusmenuMenuitem::prop-changed will be
        emitted by this function.
        @param property: Name of the property to set.
        @param value: The value of the property.
        @type property: str
        @type value: int
        @returns: A boolean representing if the property value was set.
        @rtype: bool
        """
        return object
    
    def property_set_variant(self, property=None, value=None):
        """        Takes the pair of @property and @value and places them as a
        property on @mi.  If a property already exists by that name,
        then the value is set to the new value.  If not, the property
        is added.  If the value is changed or the property was previously
        unset then the signal #DbusmenuMenuitem::prop-changed will be
        emitted by this function.
        @param property: Name of the property to set.
        @param value: The value of the property.
        @type property: str
        @type value: GLib.Variant
        @returns: A boolean representing if the property value was set.
        @rtype: bool
        """
        return object
    
    def send_about_to_show(self, cb=None, cb_data=None):
        """        This function is used to send the even that the submenu
        of this item is about to be shown.  Callers to this event
        should delay showing the menu until their callback is
        called if possible.
        @param cb: Callback to call when the call has returned.
        @param cb_data: Data to pass to the callback.
        @type cb: gpointer
        @type cb_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_parent(self, parent=None):
        """        Sets the parent of @mi to @parent. If @mi already
        has a parent, then this call will fail. The parent will
        be set automatically when using the usual methods to add a
        child menuitem, so this function should not normally be
        called directly
        @param parent: The new parent #DbusmenuMenuitem
        @type parent: Menuitem
        @returns: Whether the parent was set successfully
        @rtype: bool
        """
        return object
    
    def set_root(self, root=None):
        """        This function sets the internal value of whether this is a
        root node or not.
        @param root: Whether @mi is a root node or not
        @type root: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def show_to_user(self, timestamp=None):
        """        Signals that this menu item should be shown to the user.  If this is
        server side the server will then take it and send it over the
        bus.
        @param timestamp: The time that the user requested it to be shown
        @type timestamp: int
        @returns: 
        @rtype: None
        """
        return object
    
    def take_children(self):
        """        While the name sounds devious that's exactly what this function
        does.  It takes the list of children from the @mi and clears the
        internal list.  The calling function is now in charge of the ref's
        on the children it has taken.  A lot of responsibility involved
        in taking children.
        @returns: A #GList of pointers to #DbusmenuMenuitem objects.
        @rtype: GLib.List
        """
        return object
    
    def unparent(self):
        """        Unparents the menu item @mi. If @mi doesn't have a
        parent, then this call will fail. The menuitem will
        be unparented automatically when using the usual methods
        to delete a child menuitem, so this function should not
        normally be called directly
        @returns: Whether the menu item was unparented successfully
        @rtype: bool
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def priv(self):
        return object


class MenuitemClass():
    """Functions and signals that every menuitem should know something
about."""

    @property
    def parent_class(self):
        return object

    @property
    def property_changed(self):
        return object

    @property
    def item_activated(self):
        return object

    @property
    def child_added(self):
        return object

    @property
    def child_removed(self):
        return object

    @property
    def child_moved(self):
        return object

    @property
    def realized(self):
        return object

    @property
    def buildvariant(self):
        return object

    @property
    def handle_event(self):
        return object

    @property
    def send_about_to_show(self):
        return object

    @property
    def show_to_user(self):
        return object

    @property
    def about_to_show(self):
        return object

    @property
    def event(self):
        return object

    @property
    def reserved1(self):
        return object

    @property
    def reserved2(self):
        return object

    @property
    def reserved3(self):
        return object

    @property
    def reserved4(self):
        return object

    @property
    def reserved5(self):
        return object


class MenuitemPrivate():
    """These are the little secrets that we don't want getting
	out of data that we have.  They can still be gotten using
	accessor functions, but are protected appropriately."""


class MenuitemProxy(Menuitem):
    """Public instance data for a #DbusmenuMenuitemProxy."""
    
    def __init__(self, mi=None):
        """        Builds a new #DbusmenuMenuitemProxy object that proxies
        all of the values for @mi.
        @param mi: The #DbusmenuMenuitem to proxy
        @type mi: Menuitem
        @returns: Newly created MenuitemProxy
        @rtype: MenuitemProxy
        """
        return object
    @staticmethod
    def new(mi=None):
        """        Builds a new #DbusmenuMenuitemProxy object that proxies
        all of the values for @mi.
        @param mi: The #DbusmenuMenuitem to proxy
        @type mi: Menuitem
        @returns: Newly created MenuitemProxy
        @rtype: MenuitemProxy
        """
        return object
    
    def get_wrapped(self):
        """        Accesses the private variable of which #DbusmenuMenuitem
        we are doing the proxying for.
        @returns: A #DbusmenuMenuitem object or a #NULL if we 	don't have one or there is an error.
        @rtype: Menuitem
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def priv(self):
        return object


class MenuitemProxyClass():
    """Functions and signal slots for #DbusmenuMenuitemProxy."""

    @property
    def parent_class(self):
        return object

    @property
    def reserved1(self):
        return object

    @property
    def reserved2(self):
        return object

    @property
    def reserved3(self):
        return object

    @property
    def reserved4(self):
        return object


class MenuitemProxyPrivate():
    """"""


class Server(GObject.Object):
    """A server which represents a sharing of a set of
	#DbusmenuMenuitems across DBus to a #DbusmenuClient."""
    
    def __init__(self, object=None):
        """        Creates a new #DbusmenuServer object with a specific object
        	path on DBus.  If @object is set to NULL the default object
        	name of "/com/canonical/dbusmenu" will be used.
        
        	Return value: A brand new #DbusmenuServer
        @param object: The object name to show for this menu structure 		on DBus.  May be NULL.
        @type object: str
        @returns: Newly created Server
        @rtype: Server
        """
        return object
    @staticmethod
    def new(object=None):
        """        Creates a new #DbusmenuServer object with a specific object
        	path on DBus.  If @object is set to NULL the default object
        	name of "/com/canonical/dbusmenu" will be used.
        
        	Return value: A brand new #DbusmenuServer
        @param object: The object name to show for this menu structure 		on DBus.  May be NULL.
        @type object: str
        @returns: Newly created Server
        @rtype: Server
        """
        return object
    
    def get_icon_paths(self):
        """        Gets the stored and exported icon paths from the server.
        @rtype: None
        """
        return object
    
    def get_status(self):
        """        Gets the current statust hat the server is sending out over
        	DBus.
        
        	Return value: The current status the server is sending
        @returns: 
        @rtype: Status
        """
        return object
    
    def get_text_direction(self):
        """        Returns the value of the text direction that is being exported
        	over DBus for this server.  It should relate to the direction
        	of the labels and other text fields that are being exported by
        	this server.
        
        	Return value: Text direction exported for this server.
        @returns: 
        @rtype: TextDirection
        """
        return object
    
    def set_icon_paths(self, icon_paths=None):
        """        Sets the icon paths for the server.  This will replace previously
        	set icon theme paths.
        @returns: 
        @rtype: None
        """
        return object
    
    def set_root(self, root=None):
        """        This function contains all of the #GValue wrapping
        	required to set the property #DbusmenuServer:root-node
        	on the server @self.
        @param root: The new root #DbusmenuMenuitem tree
        @type root: Menuitem
        @returns: 
        @rtype: None
        """
        return object
    
    def set_status(self, status=None):
        """        Changes the status of the server.
        @param status: Status value to set on the server
        @type status: Status
        @returns: 
        @rtype: None
        """
        return object
    
    def set_text_direction(self, dir=None):
        """        Sets the text direction that should be exported over DBus for
        	this server.  If the value is set to #DBUSMENU_TEXT_DIRECTION_NONE
        	the default detection will be used for setting the value and
        	exported over DBus.
        @param dir: Direction of the text
        @type dir: TextDirection
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def priv(self):
        return object


class ServerClass():
    """The class implementing the virtual functions for #DbusmenuServer."""

    @property
    def parent_class(self):
        return object

    @property
    def id_prop_update(self):
        return object

    @property
    def id_update(self):
        return object

    @property
    def layout_updated(self):
        return object

    @property
    def item_activation(self):
        return object

    @property
    def reserved1(self):
        return object

    @property
    def reserved2(self):
        return object

    @property
    def reserved3(self):
        return object

    @property
    def reserved4(self):
        return object

    @property
    def reserved5(self):
        return object

    @property
    def reserved6(self):
        return object


class ServerPrivate():
    """"""
